import { ModernBaseService } from './base/ModernBaseService';
import { EquipRepository } from '../repository/EquipRepository';
import { EquipTemplate } from '../core/manage/EquipManage';
import { DataEquip, Item } from '../shared/face';
import { ItemType, quality } from '../shared/face/enums';
import MailManage from '../core/manage/MailManage';

/**
 * 现代化装备服务 - 统一管理装备模板与装备实例
 */
export class ModernEquipService extends ModernBaseService {
    private _equipRepository?: EquipRepository;

    constructor(container?: any) {
        super(container);
    }

    /**
     * 懒加载装备仓储
     */
    private get equipRepository(): EquipRepository {
        if (!this._equipRepository) {
            this._equipRepository = this.getService<EquipRepository>('EquipRepository');
        }
        return this._equipRepository;
    }

    /**
     * 初始化装备服务
     */
    async initialize(): Promise<void> {
        try {
            this.log('正在初始化现代化装备服务...');
            
            // 初始化装备仓储
            await this.equipRepository.initialize();
            
            this.log('现代化装备服务初始化完成');
        } catch (error) {
            this.log('现代化装备服务初始化失败: ' + (error as any).message, 'error');
            throw error;
        }
    }

    // ============ 装备模板管理 ============

    /**
     * 保存装备模板到数据库（模板创建即默认可用）
     * @param template 装备模板数据
     * @param creator 创建者ID
     * @returns 保存的模板ID
     */
    async saveTemplate(template: EquipTemplate, creator: string): Promise<string> {
        this.validateRequiredParams({ template, creator }, ['template', 'creator']);
        
        try {
            // 设置创建者
            const templateWithCreator = {
                ...template,
                creator: creator,
                createTime: Date.now(),
                updateTime: Date.now()
            };

            // 保存模板
            const templateId = await this.equipRepository.saveTemplate(templateWithCreator);
            
            this.log(`装备模板保存成功: ${template.name} (ID: ${templateId})`);
            
            // 创建者为玩家时，发送创建成功奖励
            if (creator !== 'sys') {
                await this.sendCreationReward(templateId, creator);
            }
            
            return templateId;
        } catch (error) {
            this.log('保存装备模板失败: ' + (error as any).message, 'error');
            throw error;
        }
    }

    /**
     * 根据ID获取装备模板
     * @param id 模板ID
     * @returns 装备模板
     */
    async getTemplateById(id: string): Promise<EquipTemplate | undefined> {
        return await this.equipRepository.getTemplateById(id);
    }

    /**
     * 获取所有装备模板
     * @returns 所有装备模板
     */
    async getAllTemplates(): Promise<EquipTemplate[]> {
        return await this.equipRepository.getAllTemplates();
    }

    /**
     * 随机获取一个装备模板ID
     */
    async getRandomTemplateId(): Promise<string> {
        return await this.equipRepository.getRandomTemplateId();
    }

    /**
     * 获取随机装备模板
     * @returns 随机装备模板，如果没有则返回undefined
     */
    async getRandomTemplate(): Promise<EquipTemplate | undefined> {
        return await this.equipRepository.getRandomTemplate();
    }

    /**
     * 删除装备模板
     * @param templateId 模板ID
     */
    async deleteTemplate(templateId: string): Promise<boolean> {
        return await this.equipRepository.deleteTemplate(templateId);
    }

    /**
     * 更新装备模板
     * @param templateId 模板ID
     * @param updates 更新数据
     */
    async updateTemplate(templateId: string, updates: Partial<EquipTemplate>): Promise<boolean> {
        return await this.equipRepository.updateTemplate(templateId, updates);
    }

    /**
     * 按条件搜索装备模板
     */
    async searchTemplates(criteria: {
        sys?: string;
        type?: string;
        job?: string;
        solt_type?: string;
        creator?: string;
        qualityMin?: quality;
        qualityMax?: quality;
    }): Promise<EquipTemplate[]> {
        return await this.equipRepository.searchTemplates(criteria);
    }

    /**
     * 获取装备模板统计信息
     */
    async getTemplateStats(): Promise<{
        total: number;
        bySys: Record<string, number>;
        byType: Record<string, number>;
        byJob: Record<string, number>;
        byCreator: Record<string, number>;
    }> {
        return await this.equipRepository.getTemplateStats();
    }

    // ============ 装备实例管理 ============

    /**
     * 根据模板创建装备实例
     * @param templateId 模板ID
     * @param customQuality 自定义品质（可选）
     * @returns 装备实例
     */
    async createEquipFromTemplate(templateId: string, customQuality?: quality): Promise<DataEquip | null> {
        this.validateRequiredParams({ templateId }, ['templateId']);
        
        try {
            const template = await this.getTemplateById(templateId);
            if (!template) {
                this.log(`装备模板不存在: ${templateId}`, 'error');
                return null;
            }

            // 确定品质
            let finalQuality: quality;
            if (customQuality !== undefined) {
                finalQuality = customQuality;
            } else {
                // 在模板定义的品质范围内随机
                const minQ = template.quality.min;
                const maxQ = template.quality.max;
                finalQuality = Math.floor(Math.random() * (maxQ - minQ + 1)) + minQ;
            }

            // 创建装备道具
            const item = this.sdk.prop.createProp({
                type: ItemType.装备,
                id: templateId,
                count: 1
            });

            const equip = item.data as DataEquip;
            
            // 设置品质
            equip.quality = finalQuality;
            
            // 重新生成属性（基于最终品质）
            equip.attribute = this.sdk.prop.createEquipAttribute(
                equip.sys, 
                equip.type, 
                equip.job, 
                equip.solt_type, 
                finalQuality
            );

            this.log(`创建装备成功: ${equip.name} (品质: ${quality[finalQuality]})`);
            return equip;
        } catch (error) {
            this.log('创建装备失败: ' + (error as any).message, 'error');
            return null;
        }
    }

    /**
     * 批量创建装备实例
     * @param templateId 模板ID
     * @param count 数量
     * @param customQuality 自定义品质（可选）
     * @returns 装备实例数组
     */
    async createEquipsFromTemplate(templateId: string, count: number, customQuality?: quality): Promise<DataEquip[]> {
        this.validateRequiredParams({ templateId, count }, ['templateId', 'count']);
        
        const equips: DataEquip[] = [];
        
        for (let i = 0; i < count; i++) {
            const equip = await this.createEquipFromTemplate(templateId, customQuality);
            if (equip) {
                equips.push(equip);
            }
        }
        
        this.log(`批量创建装备成功: ${equips.length}/${count} 件`);
        return equips;
    }

    /**
     * 装备转换为道具
     * @param equip 装备对象
     * @returns 道具对象
     */
    equipToItem(equip: DataEquip): Item {
        return this.sdk.prop.coverEquipToItem(equip);
    }

    /**
     * 道具转换为装备
     * @param item 道具对象
     * @returns 装备对象
     */
    itemToEquip(item: Item): DataEquip | null {
        if (item.type !== ItemType.装备) {
            this.log('道具类型不是装备', 'error');
            return null;
        }
        
        return item.data as DataEquip;
    }

    // ============ 奖励系统 ============

    /**
     * 发送创建成功奖励（通过邮件发放所创建的装备）
     */
    private async sendCreationReward(templateId: string, creator: string): Promise<void> {
        try {
            const template = await this.getTemplateById(templateId);
            if (!template) {
                this.log(`装备模板不存在，无法发送创建奖励: ${templateId}`, 'error');
                return;
            }

            const rewardItems = [
                this.sdk.prop.createProp({ type: ItemType.装备, id: templateId, count: 1 }),
            ];

            await MailManage.send(
                'admin',
                creator,
                30,
                '装备创建成功',
                `恭喜！您创建的装备"${template.name}"已收录,感谢您的贡献，特此奖励您1件该装备。`,
                rewardItems
            );

            this.log(`创建奖励邮件发送成功: 装备 ${templateId} -> ${creator}`);
        } catch (error) {
            this.log('发送创建奖励邮件失败: ' + (error as any).message, 'error');
        }
    }

    // ============ 兼容性方法 ============

    /**
     * 兼容旧接口：静态方法风格的模板获取
     */
    getTemplateByIdSync(id: string): EquipTemplate | undefined {
        // 注意：这是同步方法，只能返回已缓存的数据
        // 在实际使用中应该使用异步的 getTemplateById
        const cached = (this.equipRepository as any).equipTemplates?.get(id);
        if (!cached) {
            this.log(`同步获取装备模板失败，请使用异步方法: ${id}`, 'warn');
        }
        return cached;
    }

    /**
     * 兼容旧接口：静态方法风格的随机模板ID获取
     */
    getRandomTemplateIdSync(): string {
        // 注意：这是同步方法，只能返回已缓存的数据
        const cached = (this.equipRepository as any).equipTemplates;
        if (!cached || cached.size === 0) {
            this.log('同步获取随机装备模板ID失败，请使用异步方法', 'warn');
            return '';
        }
        
        const templates = Array.from(cached.values()) as EquipTemplate[];
        const randomIndex = Math.floor(Math.random() * templates.length);
        return templates[randomIndex].id;
    }

    /**
     * 兼容旧接口：静态方法风格的随机模板获取
     */
    getRandomTemplateSync(): EquipTemplate | undefined {
        // 注意：这是同步方法，只能返回已缓存的数据
        const cached = (this.equipRepository as any).equipTemplates;
        if (!cached || cached.size === 0) {
            this.log('同步获取随机装备模板失败，请使用异步方法', 'warn');
            return undefined;
        }
        
        const templates = Array.from(cached.values()) as EquipTemplate[];
        const randomIndex = Math.floor(Math.random() * templates.length);
        return templates[randomIndex];
    }
}
